home *** CD-ROM | disk | FTP | other *** search
/ CD/PC Actual 31 / PC Actual CD 31.iso / dists / SRC / SLIBEXEC.AA / SLIBEXEC / libexec / rbootd / rmp_var.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-29  |  9.1 KB  |  245 lines
  1. /*
  2.  * Copyright (c) 1988, 1992 The University of Utah and the Center
  3.  *    for Software Science (CSS).
  4.  * Copyright (c) 1992, 1993
  5.  *    The Regents of the University of California.  All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * the Center for Software Science of the University of Utah Computer
  9.  * Science Department.  CSS requests users of this software to return
  10.  * to css-dist@cs.utah.edu any improvements that they make and grant
  11.  * CSS redistribution rights.
  12.  *
  13.  * Redistribution and use in source and binary forms, with or without
  14.  * modification, are permitted provided that the following conditions
  15.  * are met:
  16.  * 1. Redistributions of source code must retain the above copyright
  17.  *    notice, this list of conditions and the following disclaimer.
  18.  * 2. Redistributions in binary form must reproduce the above copyright
  19.  *    notice, this list of conditions and the following disclaimer in the
  20.  *    documentation and/or other materials provided with the distribution.
  21.  * 3. All advertising materials mentioning features or use of this software
  22.  *    must display the following acknowledgement:
  23.  *    This product includes software developed by the University of
  24.  *    California, Berkeley and its contributors.
  25.  * 4. Neither the name of the University nor the names of its contributors
  26.  *    may be used to endorse or promote products derived from this software
  27.  *    without specific prior written permission.
  28.  *
  29.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  30.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  31.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  32.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  33.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  34.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  35.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  36.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  37.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  38.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  39.  * SUCH DAMAGE.
  40.  *
  41.  *    from: @(#)rmp_var.h    8.1 (Berkeley) 6/4/93
  42.  *
  43.  * from: Utah Hdr: rmp_var.h 3.1 92/07/06
  44.  * Author: Jeff Forys, University of Utah CSS
  45.  */
  46.  
  47. /*
  48.  *  Possible values for "rmp_type" fields.
  49.  */
  50.  
  51. #define    RMP_BOOT_REQ    1    /* boot request packet */
  52. #define    RMP_BOOT_REPL    129    /* boot reply packet */
  53. #define    RMP_READ_REQ    2    /* read request packet */
  54. #define    RMP_READ_REPL    130    /* read reply packet */
  55. #define    RMP_BOOT_DONE    3    /* boot complete packet */
  56.  
  57. /*
  58.  *  Useful constants.
  59.  */
  60.  
  61. #define RMP_VERSION    2    /* protocol version */
  62. #define RMP_TIMEOUT    600    /* timeout connection after ten minutes */
  63. #define    RMP_PROBESID    0xffff    /* session ID for probes */
  64. #define    RMP_HOSTLEN    13    /* max length of server's name */
  65. #define    RMP_MACHLEN    20    /* length of machine type field */
  66.  
  67. /*
  68.  *  RMP error codes
  69.  */
  70.  
  71. #define    RMP_E_OKAY    0
  72. #define    RMP_E_EOF    2    /* read reply: returned end of file */
  73. #define    RMP_E_ABORT    3    /* abort operation */
  74. #define    RMP_E_BUSY    4    /* boot reply: server busy */
  75. #define    RMP_E_TIMEOUT    5    /* lengthen time out (not implemented) */
  76. #define    RMP_E_NOFILE    16    /* boot reply: file does not exist */
  77. #define RMP_E_OPENFILE    17    /* boot reply: file open failed */
  78. #define    RMP_E_NODFLT    18    /* boot reply: default file does not exist */
  79. #define RMP_E_OPENDFLT    19    /* boot reply: default file open failed */
  80. #define    RMP_E_BADSID    25    /* read reply: bad session ID */
  81. #define RMP_E_BADPACKET    27     /* Bad packet detected */
  82.  
  83. /*
  84.  *  RMPDATALEN is the maximum number of data octets that can be stuffed
  85.  *  into an RMP packet.  This excludes the 802.2 LLC w/HP extensions.
  86.  */
  87. #define RMPDATALEN    (RMP_MAX_PACKET - (sizeof(struct hp_hdr) + \
  88.                                sizeof(struct hp_llc)))
  89.  
  90. /*
  91.  *  Define sizes of packets we send.  Boot and Read replies are variable
  92.  *  in length depending on the length of `s'.
  93.  *
  94.  *  Also, define how much space `restofpkt' can take up for outgoing
  95.  *  Boot and Read replies.  Boot Request packets are effectively
  96.  *  limited to 255 bytes due to the preceding 1-byte length field.
  97.  */
  98.  
  99. #define    RMPBOOTSIZE(s)    (sizeof(struct hp_hdr) + sizeof(struct hp_llc) + \
  100.              sizeof(struct rmp_boot_repl) + s - sizeof(restofpkt))
  101. #define    RMPREADSIZE(s)    (sizeof(struct hp_hdr) + sizeof(struct hp_llc) + \
  102.              sizeof(struct rmp_read_repl) + s - sizeof(restofpkt) \
  103.              - sizeof(u_int8_t))
  104. #define    RMPDONESIZE    (sizeof(struct hp_hdr) + sizeof(struct hp_llc) + \
  105.              sizeof(struct rmp_boot_done))
  106. #define    RMPBOOTDATA    255
  107. #define    RMPREADDATA    (RMPDATALEN - \
  108.              (2*sizeof(u_int8_t)+sizeof(u_int16_t)+sizeof(u_word)))
  109.  
  110. /*
  111.  * This protocol defines some field sizes as "rest of ethernet packet".
  112.  * There is no easy way to specify this in C, so we use a one character
  113.  * field to denote it, and index past it to the end of the packet.
  114.  */
  115.  
  116. typedef char    restofpkt;
  117.  
  118. /*
  119.  * Due to the RMP packet layout, we'll run into alignment problems
  120.  * on machines that can't access (or don't, by default, align) words
  121.  * on half-word boundaries.  If you know that your machine does not suffer
  122.  * from this problem, add it to the vax/tahoe/m68k #define below.
  123.  *
  124.  * The following macros are used to deal with this problem:
  125.  *    WORDZE(w)    Return True if u_word `w' is zero, False otherwise.
  126.  *    ZEROWORD(w)    Set u_word `w' to zero.
  127.  *    COPYWORD(w1,w2)    Copy u_word `w1' to `w2'.
  128.  *    GETWORD(w,i)    Copy u_word `w' into int `i'.
  129.  *    PUTWORD(i,w)    Copy int `i' into u_word `w'.
  130.  *
  131.  * N.B. Endianness is handled by use of ntohl/htonl
  132.  */
  133. #if defined(__vax__) || defined(__tahoe__) || defined(__m68k__)
  134.  
  135. typedef    u_int32_t    u_word;
  136.  
  137. #define    WORDZE(w)    ((w) == 0)
  138. #define    ZEROWORD(w)    (w) = 0
  139. #define    COPYWORD(w1,w2)    (w2) = (w1)
  140. #define    GETWORD(w, i)    (i) = ntohl(w)
  141. #define    PUTWORD(i, w)    (w) = htonl(i)
  142.  
  143. #else
  144.  
  145. #define    _WORD_HIGHPART    0
  146. #define    _WORD_LOWPART    1
  147.  
  148. typedef    struct _uword { u_int16_t val[2]; }    u_word;
  149.  
  150. #define    WORDZE(w) \
  151.     ((w.val[_WORD_HIGHPART] == 0) && (w.val[_WORD_LOWPART] == 0))
  152. #define    ZEROWORD(w) \
  153.     (w).val[_WORD_HIGHPART] = (w).val[_WORD_LOWPART] = 0
  154. #define    COPYWORD(w1, w2) \
  155.     { (w2).val[_WORD_HIGHPART] = (w1).val[_WORD_HIGHPART]; \
  156.       (w2).val[_WORD_LOWPART] = (w1).val[_WORD_LOWPART]; \
  157.     }
  158. #define    GETWORD(w, i) \
  159.     (i) = (((u_int32_t)ntohs((w).val[_WORD_HIGHPART])) << 16) | ntohs((w).val[_WORD_LOWPART])
  160. #define    PUTWORD(i, w) \
  161.     { (w).val[_WORD_HIGHPART] = htons((u_int16_t) ((i >> 16) & 0xffff)); \
  162.       (w).val[_WORD_LOWPART] = htons((u_int16_t) (i & 0xffff)); \
  163.     }
  164.  
  165. #endif
  166.  
  167. /*
  168.  * Packet structures.
  169.  */
  170.  
  171. struct rmp_raw {        /* generic RMP packet */
  172.     u_int8_t  rmp_type;        /* packet type */
  173.     u_int8_t  rmp_rawdata[RMPDATALEN-1];
  174. };
  175.  
  176. struct rmp_boot_req {        /* boot request */
  177.     u_int8_t  rmp_type;        /* packet type (RMP_BOOT_REQ) */
  178.     u_int8_t  rmp_retcode;        /* return code (0) */
  179.     u_word      rmp_seqno;        /* sequence number (real time clock) */
  180.     u_int16_t rmp_session;        /* session id (normally 0) */
  181.     u_int16_t rmp_version;        /* protocol version (RMP_VERSION) */
  182.     char      rmp_machtype[RMP_MACHLEN];    /* machine type */
  183.     u_int8_t  rmp_flnmsize;        /* length of rmp_flnm */
  184.     restofpkt rmp_flnm;        /* name of file to be read */
  185. };
  186.  
  187. struct rmp_boot_repl {        /* boot reply */
  188.     u_int8_t  rmp_type;        /* packet type (RMP_BOOT_REPL) */
  189.     u_int8_t  rmp_retcode;        /* return code (normally 0) */
  190.     u_word      rmp_seqno;        /* sequence number (from boot req) */
  191.     u_int16_t rmp_session;        /* session id (generated) */
  192.     u_int16_t rmp_version;        /* protocol version (RMP_VERSION) */
  193.     u_int8_t  rmp_flnmsize;        /* length of rmp_flnm */
  194.     restofpkt rmp_flnm;        /* name of file (from boot req) */
  195. };
  196.  
  197. struct rmp_read_req {        /* read request */
  198.     u_int8_t  rmp_type;        /* packet type (RMP_READ_REQ) */
  199.     u_int8_t  rmp_retcode;        /* return code (0) */
  200.     u_word      rmp_offset;        /* file relative byte offset */
  201.     u_int16_t rmp_session;        /* session id (from boot repl) */
  202.     u_int16_t rmp_size;        /* max no of bytes to send */
  203. };
  204.  
  205. struct rmp_read_repl {        /* read reply */
  206.     u_int8_t  rmp_type;        /* packet type (RMP_READ_REPL) */
  207.     u_int8_t  rmp_retcode;        /* return code (normally 0) */
  208.     u_word      rmp_offset;        /* byte offset (from read req) */
  209.     u_int16_t rmp_session;        /* session id (from read req) */
  210.     restofpkt rmp_data;        /* data (max size from read req) */
  211.     u_int8_t  rmp_unused;        /* padding to 16-bit boundary */
  212. };
  213.  
  214. struct rmp_boot_done {        /* boot complete */
  215.     u_int8_t  rmp_type;        /* packet type (RMP_BOOT_DONE) */
  216.     u_int8_t  rmp_retcode;        /* return code (0) */
  217.     u_word      rmp_unused;        /* not used (0) */
  218.     u_int16_t rmp_session;        /* session id (from read repl) */
  219. };
  220.  
  221. struct rmp_packet {
  222.     struct hp_hdr hp_hdr;
  223.     struct hp_llc hp_llc;
  224.     union {
  225.         struct rmp_boot_req    rmp_brq;    /* boot request */
  226.         struct rmp_boot_repl    rmp_brpl;    /* boot reply */
  227.         struct rmp_read_req    rmp_rrq;    /* read request */
  228.         struct rmp_read_repl    rmp_rrpl;    /* read reply */
  229.         struct rmp_boot_done    rmp_done;    /* boot complete */
  230.         struct rmp_raw        rmp_raw;    /* raw data */
  231.     } rmp_proto;
  232. };
  233.  
  234. /*
  235.  *  Make life easier...
  236.  */
  237.  
  238. #define    r_type    rmp_proto.rmp_raw.rmp_type
  239. #define    r_data    rmp_proto.rmp_raw.rmp_rawdata
  240. #define    r_brq    rmp_proto.rmp_brq
  241. #define    r_brpl    rmp_proto.rmp_brpl
  242. #define    r_rrq    rmp_proto.rmp_rrq
  243. #define    r_rrpl    rmp_proto.rmp_rrpl
  244. #define    r_done    rmp_proto.rmp_done
  245.